// API 客户端 - 连接 PostgreSQL 后端服务
class PortfolioApi {
  constructor() {
    this.baseUrl = process.env.REACT_APP_API_URL || 'http://localhost:9081/api';
  }

  // 处理 API 响应
  async handleResponse(response) {
    if (!response.ok) {
      const error = await response.json().catch(() => ({ error: '网络错误' }));
      throw new Error(error.error || `HTTP ${response.status}`);
    }
    return response.json();
  }

  // 初始化（检查服务器连接）
  async init() {
    try {
      console.log('🔗 尝试连接 API:', this.baseUrl);
      const response = await fetch(`${this.baseUrl}/health`);
      console.log('📡 API 响应状态:', response.status);
      
      await this.handleResponse(response);
      console.log('✅ API 连接成功');
      return true;
    } catch (err) {
      console.error('❌ API 服务连接失败:', err);
      
      if (err.name === 'TypeError' && err.message.includes('Failed to fetch')) {
        throw new Error(`无法连接到服务器 ${this.baseUrl}。可能原因：\n1. 服务器未启动\n2. 网络连接问题\n3. CORS 配置问题`);
      }
      
      throw new Error(`服务器连接失败: ${err.message}`);
    }
  }

  // 添加作品
  async addWork(workData) {
    try {
      const response = await fetch(`${this.baseUrl}/works`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(workData),
      });
      return await this.handleResponse(response);
    } catch (err) {
      console.error('添加作品失败:', err);
      throw new Error(err.message || '添加作品失败');
    }
  }

  // 获取所有作品（支持分页和课程筛选）
  async getAllWorks(page = 1, limit = 10, courseId = null) {
    try {
      let url = `${this.baseUrl}/works?page=${page}&limit=${limit}`;
      if (courseId) {
        url += `&courseId=${courseId}`;
      }
      const response = await fetch(url);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('获取作品列表失败:', err);
      throw new Error(err.message || '获取作品列表失败');
    }
  }

  // 根据ID获取作品
  async getWorkById(id) {
    try {
      const response = await fetch(`${this.baseUrl}/works/${id}`);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('获取作品失败:', err);
      throw new Error(err.message || '获取作品失败');
    }
  }

  // 更新作品
  async updateWork(workData) {
    try {
      const response = await fetch(`${this.baseUrl}/works/${workData.id}`, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(workData),
      });
      return await this.handleResponse(response);
    } catch (err) {
      console.error('更新作品失败:', err);
      throw new Error(err.message || '更新作品失败');
    }
  }

  // 删除作品
  async deleteWork(id) {
    try {
      const response = await fetch(`${this.baseUrl}/works/${id}`, {
        method: 'DELETE',
      });
      await this.handleResponse(response);
      return true;
    } catch (err) {
      console.error('删除作品失败:', err);
      throw new Error(err.message || '删除作品失败');
    }
  }

  // 搜索作品
  async searchWorks(searchTerm) {
    try {
      if (!searchTerm.trim()) {
        return await this.getAllWorks();
      }

      const response = await fetch(`${this.baseUrl}/works/search/${encodeURIComponent(searchTerm)}`);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('搜索失败:', err);
      throw new Error(err.message || '搜索失败');
    }
  }

  // 批量删除所有作品
  async deleteAllWorks() {
    try {
      const response = await fetch(`${this.baseUrl}/works`, {
        method: 'DELETE',
      });
      await this.handleResponse(response);
      return true;
    } catch (err) {
      console.error('批量删除失败:', err);
      throw new Error(err.message || '批量删除失败');
    }
  }

  // 批量导入作品
  async importWorks(works) {
    try {
      const response = await fetch(`${this.baseUrl}/works/import`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ works }),
      });
      return await this.handleResponse(response);
    } catch (err) {
      console.error('导入失败:', err);
      throw new Error(err.message || '导入失败');
    }
  }

  // 管理员登录
  async adminLogin(username, password) {
    try {
      const response = await fetch(`${this.baseUrl}/admin/login`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ username, password }),
      });
      return await this.handleResponse(response);
    } catch (err) {
      console.error('管理员登录失败:', err);
      throw new Error(err.message || '管理员登录失败');
    }
  }

  // 获取所有管理员
  async getAllAdmins() {
    try {
      const response = await fetch(`${this.baseUrl}/admins`);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('获取管理员列表失败:', err);
      throw new Error(err.message || '获取管理员列表失败');
    }
  }

  // 获取所有课程
  async getAllCourses(adminId = null) {
    try {
      let url = `${this.baseUrl}/courses`;
      if (adminId) {
        url += `?adminId=${adminId}`;
      }
      const response = await fetch(url);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('获取课程列表失败:', err);
      throw new Error(err.message || '获取课程列表失败');
    }
  }

  // 根据ID获取课程
  async getCourseById(id) {
    try {
      const response = await fetch(`${this.baseUrl}/courses/${id}`);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('获取课程失败:', err);
      throw new Error(err.message || '获取课程失败');
    }
  }

  // 添加课程
  async addCourse(courseData) {
    try {
      const response = await fetch(`${this.baseUrl}/courses`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(courseData),
      });
      return await this.handleResponse(response);
    } catch (err) {
      console.error('添加课程失败:', err);
      throw new Error(err.message || '添加课程失败');
    }
  }

  // 更新课程
  async updateCourse(courseData) {
    try {
      const response = await fetch(`${this.baseUrl}/courses/${courseData.id}`, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(courseData),
      });
      return await this.handleResponse(response);
    } catch (err) {
      console.error('更新课程失败:', err);
      throw new Error(err.message || '更新课程失败');
    }
  }

  // 删除课程
  async deleteCourse(id) {
    try {
      const response = await fetch(`${this.baseUrl}/courses/${id}`, {
        method: 'DELETE',
      });
      await this.handleResponse(response);
      return true;
    } catch (err) {
      console.error('删除课程失败:', err);
      throw new Error(err.message || '删除课程失败');
    }
  }

  // 获取管理员的所有作品
  async getAdminWorks(adminId) {
    try {
      const response = await fetch(`${this.baseUrl}/admin/${adminId}/works`);
      return await this.handleResponse(response);
    } catch (err) {
      console.error('获取管理员作品失败:', err);
      throw new Error(err.message || '获取管理员作品失败');
    }
  }

  // 初始化示例数据（后端已处理）
  async initSampleData() {
    // PostgreSQL 后端在数据库初始化时已插入示例数据
    // 这里只需要检查是否有数据即可
    const result = await this.getAllWorks();
    return result.works && result.works.length > 0;
  }
}

// 创建 API 实例
const portfolioApi = new PortfolioApi();

export default portfolioApi;
